////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2017-2018 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  camxipecolorcorrection13.h
/// @brief IPEColorCorrection class declarations
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef CAMXIPECOLORCORRECTION13_H
#define CAMXIPECOLORCORRECTION13_H

#include "camxformats.h"
#include "camxispiqmodule.h"
#include "iqcommondefs.h"

CAMX_NAMESPACE_BEGIN

CAMX_BEGIN_PACKED

// @brief: This structure contains Color Correction registers programmed by software
struct IPECC13RegConfig
{
    IPE_IPE_0_PPS_CLC_COLOR_CORRECT_COLOR_CORRECT_COEFF_A_CFG_0     greenCoefficients0; ///< Coefficents for input green
    IPE_IPE_0_PPS_CLC_COLOR_CORRECT_COLOR_CORRECT_COEFF_A_CFG_1     greenCoefficients1; ///< Coefficents for input green
    IPE_IPE_0_PPS_CLC_COLOR_CORRECT_COLOR_CORRECT_COEFF_B_CFG_0     blueCoefficients0;  ///< Coefficents for input blue
    IPE_IPE_0_PPS_CLC_COLOR_CORRECT_COLOR_CORRECT_COEFF_B_CFG_1     blueCoefficients1;  ///< Coefficents for input blue
    IPE_IPE_0_PPS_CLC_COLOR_CORRECT_COLOR_CORRECT_COEFF_C_CFG_0     redCoefficients0;   ///< Coefficents for input red
    IPE_IPE_0_PPS_CLC_COLOR_CORRECT_COLOR_CORRECT_COEFF_C_CFG_1     redCoefficients1;   ///< Coefficents for input red
    IPE_IPE_0_PPS_CLC_COLOR_CORRECT_COLOR_CORRECT_OFFSET_K_CFG_0    offsetParam0;       ///< Addition offset params for outputs
    IPE_IPE_0_PPS_CLC_COLOR_CORRECT_COLOR_CORRECT_OFFSET_K_CFG_1    offsetParam1;       ///< Addition offset params for outputs
    IPE_IPE_0_PPS_CLC_COLOR_CORRECT_COLOR_CORRECT_SHIFT_M_CFG       qFactor;            ///< Right shift for Q factor adjustment
} CAMX_PACKED;

CAMX_END_PACKED

static const UINT32 DefaultSaturation           = 5;
static const UINT32 IPEColorCorrectionRegLength = sizeof(IPECC13RegConfig) / RegisterWidthInBytes;
CAMX_STATIC_ASSERT((9 * 4) == sizeof(IPECC13RegConfig));

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Class for IPE ColorCorrection13 Module
///
///         This IQ blocks compensates global chroma difference due to R/G/B channel crosstalk by applying
///         a 3x3 matrix color correction matrix(CCM)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class IPEColorCorrection13 final : public ISPIQModule
{
public:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Create
    ///
    /// @brief  Create Color Correction Object
    ///
    /// @param  pCreateData  Pointer to resource and intialization data for ColorCorrection13 Creation
    ///
    /// @return CamxResultSuccess if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static CamxResult Create(
        IPEModuleCreateData* pCreateData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Initialize
    ///
    /// @brief  Initialize parameters
    ///
    /// @return CamxResultSuccess if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual CamxResult Initialize();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Execute
    ///
    /// @brief  Execute process capture request to configure module
    ///
    /// @param  pInputData Pointer to the ISP input data
    ///
    /// @return CamxResultSuccess if successful.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual CamxResult Execute(
        ISPInputData* pInputData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetRegCmd
    ///
    /// @brief  Retrieve the buffer of the register value
    ///
    /// @return Pointer of the register buffer
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual VOID* GetRegCmd();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ~IPEColorCorrection13
    ///
    /// @brief  Destructor
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ~IPEColorCorrection13();

protected:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// IPEColorCorrection13
    ///
    /// @brief  Constructor
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    IPEColorCorrection13();

private:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// AllocateCommonLibraryData
    ///
    /// @brief  Allocate memory required for common library
    ///
    /// @return CamxResult success if the write operation is success
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult AllocateCommonLibraryData();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// DeallocateCommonLibraryData
    ///
    /// @brief  Deallocate memory required for common library
    ///
    /// @return CamxResult success if the write operation is success
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult DeallocateCommonLibraryData();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ValidateDependenceParams
    ///
    /// @brief  Validate the input configuration from app
    ///
    /// @param  pInputData Pointer to the ISP input data
    ///
    /// @return CamxResult Indicates if the input is valid or invalid
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult ValidateDependenceParams(
        const ISPInputData* pInputData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CheckDependenceChange
    ///
    /// @brief  Check to see if the Dependence Trigger Data Changed
    ///
    /// @param  pInputData Pointer to the ISP input data
    ///
    /// @return BOOL Indicates if the settings have changed compared to last setting
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL CheckDependenceChange(
        ISPInputData* pInputData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// UpdateIPEInternalData
    ///
    /// @brief  Update Pipeline input data, such as metadata, IQSettings.
    ///
    /// @param  pInputData Pointer to the ISP input data
    ///
    /// @return CamxResult success if the write operation is success
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult UpdateIPEInternalData(
        const ISPInputData* pInputData
        ) const;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// RunCalculation
    ///
    /// @brief  Calculate the Register Value
    ///
    /// @param  pInputData Pointer to the ISP input data
    ///
    /// @return CamxResult Indicates if configuration calculation was success or failure
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult RunCalculation(
        const ISPInputData* pInputData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// DumpRegConfig
    ///
    /// @brief  Print register configuration of Color Correction module for debug
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID DumpRegConfig() const;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CreateCmdList
    ///
    /// @brief  Create the Command List
    ///
    /// @param  pInputData Pointer to the ISP input data
    ///
    /// @return CamxResult success if the write operation is success
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult CreateCmdList(
        const ISPInputData* pInputData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// UpdateManualCCM
    ///
    /// @brief  Update user controlled CC matrix
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID UpdateManualCCM();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// UpdateAWBCCM
    ///
    /// @brief  Update CCM from AWB algo
    ///
    /// @param  pAWBCCM  Pointer to the AWB CCM
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID UpdateAWBCCM(
        AWBCCMParams* pAWBCCM);

    IPEColorCorrection13(const IPEColorCorrection13&)            = delete;  ///< Disallow the copy constructor
    IPEColorCorrection13& operator=(const IPEColorCorrection13&) = delete;  ///< Disallow assignment operator

    CC13InputData                 m_dependenceData;                         ///< Dependence Data for this Module
    IPECC13RegConfig              m_regCmd;                                 ///< Register List of this Module
    UINT                          m_numValidCCMs;                           ///< Number of CCMs from 3A
    AWBCCMParams                  m_AWBCCM[MaxCCMs];                        ///< CCM overide config from 3A
    FLOAT                         m_manualCCM[3][3];                        ///< CCM matrix from app
    BOOL                          m_manualCCMOverride;                      ///< Manual Control
    UINT8                         m_colorCorrectionMode;                    ///< CC mode
    cc_1_3_0::chromatix_cc13Type* m_pChromatix;                             ///< Pointer to tuning mode data
    BOOL                          m_validCCM;                               ///< regsiter have valid CCM
};

CAMX_NAMESPACE_END

#endif // CAMXIPEColorCorrection_H
